#ifndef __H_UTIL__
#define __H_UTIL__
#include "logger.hpp"
#include <string>
#include <mysql/mysql.h>
#include <memory>
#include <fstream>
#include <jsoncpp/json/json.h>
#include <sstream>
#include <vector>
class mysql_util
{
public:
    // 创建mysql客户端
    static MYSQL *mysql_create(const std::string &host,
                               const std::string &user,
                               const std::string &passwd,
                               uint32_t port,
                               const std::string &dbname)
    {
        // 初始化mysql句柄
        MYSQL *mysql = mysql_init(nullptr);
        if (mysql == nullptr)
        {
            ELOG("mysql init error: %s", mysql_error(mysql));
            return nullptr;
        }
        // 连接mysql服务器
        if (mysql_real_connect(mysql, host.c_str(), user.c_str(), passwd.c_str(), dbname.c_str(), port, nullptr, 0) == nullptr)
        {
            ELOG("mysql real connect error: %s", mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }
        // 设置客户端字符集
        if (mysql_set_character_set(mysql, "utf8") != 0)
        {
            ELOG("mysql set character error: %s", mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }
        return mysql;
    }
    // 执行sql语句
    static bool mysql_exec(MYSQL *mysql, const std::string sql)
    {
        if (mysql_query(mysql, sql.c_str()) != 0)
        {
            ELOG("execute mysql query error: %s", mysql_error(mysql));
            mysql_close(mysql);
            return false;
        }
        return true;
    }
    // 关闭连接
    static void mysql_destory(MYSQL *mysql)
    {
        if (mysql != nullptr)
            mysql_close(mysql);
    }
};

class json_util
{
public:
    // 序列化：把一个Json对象序列化为一个字符串
    static bool Serialize(const Json::Value &root, std::string &str)
    {
        // 实例化工厂类对象
        Json::StreamWriterBuilder swb;
        // 工厂对象生产StreamWriter对象
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        // 使用sw对象完成序列化
        std::stringstream ss;
        sw->write(root, &ss);
        str = ss.str();
        return true;
    }
    // 反序列化：将一个字符串转化为一个Json::Value对象
    static bool DeSerialize(const std::string &str, Json::Value &root)
    {
        // 实例化工厂类对象
        Json::CharReaderBuilder crb;
        // 工厂对象生产CharReader对象
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
        // 使用cr对象完成序列化
        std::string errs;
        if (cr->parse(str.c_str(), str.c_str() + str.size(), &root, &errs) == false)
        {
            ELOG("deserialize error: %s", errs.c_str());
            return false;
        }
        return true;
    }
};

class string_util
{
public:
    static size_t split(const std::string& str,const std::string& sep,std::vector<std::string>& res)
    {
        size_t idx = 0; //从idx位置往后查找分隔符
        while(idx < str.size())
        {
            size_t pos = str.find(sep,idx);
            //特殊处理：最后一个子串没有分隔符
            if(pos == std::string::npos)
            {
                res.push_back(str.substr(idx));
                break;
            }
            //特殊处理：例如,,,的情况
            if(pos == idx)
            {
                idx += sep.size();
                continue;
            }
            //pos - idx = 子串长度
            res.push_back(str.substr(idx,pos-idx));
            idx = pos + sep.size();
        }
        return res.size();
    }
};

class file_util
{
    public:
    static bool read(const std::string& filename,std::string& body)
    {
        //打开文件
        std::ifstream ifs(filename,std::ios::binary);
        if(ifs.is_open() == false)
        {
            ELOG("open file error! filename: %s ",filename.c_str());
            return false;
        }
        //把文件指针移到文件末尾,计算文件大小
        ifs.seekg(0,std::ios::end);
        size_t fsize = ifs.tellg();
        ifs.seekg(std::ios::beg);
        //读取文件内容
        body.resize(fsize);
        ifs.read(&body[0],fsize);
        if(ifs.good() == false)
        {
            ELOG("read file error! filename: %s",filename);
            ifs.close();
            return false;
        }
        //关闭文件
        ifs.close();
        return true;
    }
};
#endif